// #include "NLP.h"
// #include <stdlib.h>
// #include <stdio.h>

// // 1. 目标函数
// double objective(double *x) {
//     return x[0] * x[0] + x[1] * x[1];  // f(x) = x₀² + x₁²
// }

// // 2. 目标函数梯度
// void gradient(double *x, double *grad) {
//     grad[0] = 2 * x[0];  // ∂f/∂x₀ = 2x₀
//     grad[1] = 2 * x[1];  // ∂f/∂x₁ = 2x₁
// }

// // 3. 不等式约束计算（g(x) ≤ 0）
// void inequality_constraints(double *x, double *result) {
//     result[0] = x[0] + x[1] - 1;  // x₀ + x₁ ≤ 1 → g₀(x) = x₀ + x₁ - 1 ≤ 0
//     result[1] = -x[0];             // x₀ ≥ 0     → g₁(x) = -x₀ ≤ 0
//     result[2] = -x[1];             // x₁ ≥ 0     → g₂(x) = -x₁ ≤ 0
// }

// // 4. 等式约束计算（h(x) = 0）
// void equality_constraints(double *x, double *result) {
//     result[0] = x[0] * x[0] - x[1];    // h₀(x) = x₀² - x₁ = 0
//     result[1] = x[0] + x[1] * x[1] - 1; // h₁(x) = x₀ + x₁² - 1 = 0
// }

// // 5. 不等式约束的雅可比矩阵（m×n）
// void jacobian_ineq(double *x, double **jac) {
//     // 第1个约束 g₀(x) = x₀ + x₁ -1 的梯度
//     jac[0][0] = 1;   // ∂g₀/∂x₀ = 1
//     jac[0][1] = 1;   // ∂g₀/∂x₁ = 1
    
//     // 第2个约束 g₁(x) = -x₀ 的梯度
//     jac[1][0] = -1;  // ∂g₁/∂x₀ = -1
//     jac[1][1] = 0;   // ∂g₁/∂x₁ = 0
    
//     // 第3个约束 g₂(x) = -x₁ 的梯度
//     jac[2][0] = 0;   // ∂g₂/∂x₀ = 0
//     jac[2][1] = -1;  // ∂g₂/∂x₁ = -1
// }

// // 6. 等式约束的雅可比矩阵（p×n）
// void jacobian_eq(double *x, double **jac) {
//     // 第1个等式 h₀(x) = x₀² - x₁ 的梯度
//     jac[0][0] = 2 * x[0];  // ∂h₀/∂x₀ = 2x₀
//     jac[0][1] = -1;        // ∂h₀/∂x₁ = -1
    
//     // 第2个等式 h₁(x) = x₀ + x₁² -1 的梯度
//     jac[1][0] = 1;         // ∂h₁/∂x₀ = 1
//     jac[1][1] = 2 * x[1];  // ∂h₁/∂x₁ = 2x₁
// }

// // 分配二维矩阵内存
// double** allocate_matrix(int rows, int cols) {
//     double **matrix = (double **)malloc(rows * sizeof(double *));
//     if (!matrix) return NULL;
    
//     for (int i = 0; i < rows; i++) {
//         matrix[i] = (double *)malloc(cols * sizeof(double));
//         if (!matrix[i]) {
//             // 分配失败时释放已分配的内存
//             for (int j = 0; j < i; j++) free(matrix[j]);
//             free(matrix);
//             return NULL;
//         }
//     }
//     return matrix;
// }

// // 释放二维矩阵内存
// void free_matrix(double **matrix, int rows) {
//     if (!matrix) return;
    
//     for (int i = 0; i < rows; i++) {
//         free(matrix[i]);
//     }
//     free(matrix);
// }


#include "nlp.h"
#include <stdlib.h>

// 目标函数
double objective(double *x) {
    return x[0]*x[0] + x[1]*x[1]; // 示例
}

// 目标函数梯度
void gradient(double *x, double *grad) {
    grad[0] = 2*x[0];
    grad[1] = 2*x[1];
}

// 不等式约束
void inequality_constraints(double *x, double *result) {
    result[0] = x[0] - 1; // g0(x) = x0 - 1 ≤ 0
    result[1] = x[1] - 1; // g1(x) = x1 - 1 ≤ 0
}

// 等式约束
void equality_constraints(double *x, double *result) {
    result[0] = x[0] + x[1] - 2; // h0(x) = x0 + x1 - 2 = 0
}

// 不等式约束雅可比（一维数组，行优先存储）
void jacobian_ineq(double *x, double *jac) {
    // g0的梯度: ∂g0/∂x0 = 1, ∂g0/∂x1 = 0
    jac[0] = 1; jac[1] = 0;
    // g1的梯度: ∂g1/∂x0 = 0, ∂g1/∂x1 = 1
    jac[2] = 0; jac[3] = 1;
}

// 等式约束雅可比（一维数组，行优先存储）
void jacobian_eq(double *x, double *jac) {
    // h0的梯度: ∂h0/∂x0 = 1, ∂h0/∂x1 = 1
    jac[0] = 1; jac[1] = 1;
}

// 内存分配
double* allocate_vector(int size) {
    return (double*)malloc(size * sizeof(double));
}

void free_vector(double *vec) {
    free(vec);
}